package com.zzyl.nursing.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdcardUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.BeanUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zzyl.common.core.domain.AjaxResult;
import com.zzyl.common.core.page.TableDataInfo;
import com.zzyl.common.exception.base.BaseException;
import com.zzyl.common.utils.SecurityUtils;
import com.zzyl.common.utils.StringUtils;
import com.zzyl.nursing.domain.*;
import com.zzyl.nursing.dto.CancelDto;
import com.zzyl.nursing.dto.ExecuteTaskDto;
import com.zzyl.nursing.mapper.DeviceMapper;
import com.zzyl.nursing.mapper.ElderMapper;
import com.zzyl.nursing.mapper.NursingProjectMapper;
import com.zzyl.nursing.mapper.NursingTaskMapper;
import com.zzyl.nursing.service.*;
import com.zzyl.nursing.vo.ElderNursingVo;
import com.zzyl.nursing.vo.NursingPlanVo;
import com.zzyl.nursing.vo.NursingProjectPlanVo;

import com.zzyl.nursing.vo.NursingTaskVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 护理任务Service业务层处理
 *
 * @author ruoyi
 * @date 2024-09-27
 */
@Service
@Slf4j
public class NursingTaskServiceImpl extends ServiceImpl<NursingTaskMapper,NursingTask> implements INursingTaskService {
    @Autowired
    private NursingTaskMapper nursingTaskMapper;
    @Autowired
    private NursingProjectMapper nursingProjectMapper;
    @Autowired
    private DeviceMapper deviceMapper;
    @Autowired
    private  ElderMapper elderMapper;


    /**
     * 查询护理任务
     *
     * @param id 护理任务主键
     * @return 护理任务
     */
    @Override
    public NursingTask selectNursingTaskById(Long id) {
        return getById(id);
    }

    /**
     * 查询护理任务列表
     *
     * @param 护理任务
     * @return 护理任务
     */
    @Override
    public TableDataInfo selectNursingTaskList(NursingTaskQueryParam queryParam) {
        LambdaQueryWrapper<NursingTask> queryWrapper = new LambdaQueryWrapper<>();
        Page<NursingTask> page = new Page<>(queryParam.getPageNum(), queryParam.getPageSize());
        if (StringUtils.isNotEmpty(queryParam.getElderName())) {
            queryWrapper.like(NursingTask::getElderName, queryParam.getElderName());
        }
        if (queryParam.getNurseId() != null) {
            queryWrapper.eq(NursingTask::getNursingId, queryParam.getNurseId());
        }
        if (queryParam.getProjectId() != null) {
            queryWrapper.eq(NursingTask::getProjectId, queryParam.getProjectId());
        }
        if (queryParam.getStatus() != null) {
            queryWrapper.eq(NursingTask::getStatus, queryParam.getStatus());
        }
        if (queryParam.getStartTime() != null || queryParam.getEndTime() != null) {
            queryWrapper.between(NursingTask::getEstimatedServerTime, queryParam.getStartTime(), queryParam.getEndTime());
        }
        page = page(page, queryWrapper);
        //查询护理人员
        List<ElderNursingVo> elderNursingVos = nursingTaskMapper.selectNursingTaskNameList();
        //转化成数组
        Map<Long, String[]> nursingNameMap = elderNursingVos.stream()
                .collect(Collectors.toMap(
                        ElderNursingVo::getElderId,
                        vo -> vo.getNurseNames().split(",")  // 将字符串分割为数组
                ));
        page.getRecords().forEach(nursingTask -> {
            LambdaQueryWrapper<NursingProject> queryProject = new LambdaQueryWrapper<>();
            queryProject.eq(NursingProject::getId, nursingTask.getProjectId());
            NursingProject nursingProject = nursingProjectMapper.selectOne(queryProject);
            if (nursingProject != null) {
                nursingTask.setProjectName(nursingProject.getName());
            }
            nursingTask.setNursingName(nursingNameMap.get(nursingTask.getElderId()));
        });

        return getTableDateInfo(page);
    }



    private TableDataInfo getTableDateInfo(Page<NursingTask> page) {
        TableDataInfo tableDataInfo = new TableDataInfo<>();
        tableDataInfo.setTotal(page.getTotal());
        tableDataInfo.setRows(page.getRecords());
        tableDataInfo.setCode(200);
        tableDataInfo.setMsg("请求成功");
        return tableDataInfo;
    }



    /**
     * 新增护理任务
     *
     * @param nursingTask 护理任务
     * @return 结果
     */
    @Override
    public int insertNursingTask(NursingTask nursingTask)

    {
        return save(nursingTask)?1:0;
    }

    /**
     * 修改护理任务
     *
     * @param nursingTask 护理任务
     * @return 结果
     */
    @Override
    public int updateNursingTask(NursingTask nursingTask)
    {
        return updateById(nursingTask)?1:0;
    }

    /**
     * 批量删除护理任务
     *
     * @param ids 需要删除的护理任务主键
     * @return 结果
     */
    @Override
    public int deleteNursingTaskByIds(Long[] ids)
    {
        return removeByIds(Arrays.asList(ids))?1:0;
    }

    /**
     * 删除护理任务信息
     *
     * @param id 护理任务主键
     * @return 结果
     */
    @Override
    public int deleteNursingTaskById(Long id)
    {
        return removeById(id)?1:0;
    }

    @Autowired
    private ICheckInService checkInService;

    @Autowired
    private ICheckInConfigService checkInConfigService;

    @Autowired
    private INursingLevelService nursingLevelService;

    @Autowired
    private INursingPlanService nursingPlanService;

    @Autowired
    private INursingElderService nursingElderService;

    @Autowired
    private INursingProjectService nursingProjectService;

    /**
     * 生成护理任务
     *
     * @param elder
     */
    @Override
    public void createMonthTask(Elder elder) {
        //校验
        if (elder == null || elder.getId() == null) {
            log.info("老人不能为空");
            return;
        }

        //获取入住信息
        CheckIn checkIn = checkInService.getOne(Wrappers.<CheckIn>lambdaQuery().eq(CheckIn::getElderId, elder.getId()));

        //获取入住及入住配置信息
        CheckInConfig checkInConfig = checkInConfigService.getOne(Wrappers.<CheckInConfig>lambdaQuery().eq(CheckInConfig::getCheckInId, checkIn.getId()));
        //开始时间
        LocalDateTime startTime = LocalDateTime.now();
        //判断开始是在当天时间
        if (checkInConfig.getFeeStartDate().toLocalDate().isEqual(LocalDateTime.now().toLocalDate())) {
            startTime = checkInConfig.getFeeStartDate();
        }

        //护理等级
        NursingLevel nursingLevel = nursingLevelService.selectNursingLevelById(checkInConfig.getNursingLevelId());
        //护理计划
        NursingPlanVo nursingPlanVo = nursingPlanService.selectNursingPlanById(nursingLevel.getLplanId());
        //查询老人对应的护理员列表
        List<NursingElder> nursingElderList = nursingElderService.list(Wrappers.<NursingElder>lambdaQuery().eq(NursingElder::getElderId, elder.getId()));
        String nursingIds;
        if (CollUtil.isNotEmpty(nursingElderList)) {
            List<Long> list = nursingElderList.stream().map(NursingElder::getNursingId).collect(Collectors.toList());
            //多个id用逗号分隔，转换为字符串
            nursingIds = StringUtils.join(list, ",");
        } else {
            nursingIds = "";
        }

        //查询所有的护理项目
        List<NursingProject> list = nursingProjectService.list();
        //转换为map key是id,value是name
        Map<Long, String> nursingProjectMap = list.stream().collect(Collectors.toMap(NursingProject::getId, NursingProject::getName));

        //组装护理任务
        List<NursingTask> nursingTasks = new ArrayList<>();

        LocalDateTime finalStartTime = startTime;
        nursingPlanVo.getProjectPlans().forEach(v -> {
            //执行频次
            Integer executeFrequency = v.getExecuteFrequency();
            //执行时间
            String executeTime = v.getExecuteTime();
            LocalTime localTime = LocalTime.parse(executeTime);
            //开始执行时间
            LocalDateTime firstExecutionTime = LocalDateTime.of(finalStartTime.toLocalDate(), localTime);
            // 计算相差天数
            LocalDateTime monthEndTime = LocalDateTime.of(finalStartTime.getYear(), checkInConfig.getFeeStartDate().getMonth(), finalStartTime.toLocalDate().lengthOfMonth(), 23, 59);
            // 间隔天数
            long diffDays = monthEndTime.toLocalDate().toEpochDay() - finalStartTime.toLocalDate().toEpochDay() + 1;
            if (v.getExecuteCycle().equals(0)) {
                // 日
                createTaskByDay(firstExecutionTime, diffDays, nursingTasks, executeFrequency, elder, v, nursingIds,nursingProjectMap);
            } else if (v.getExecuteCycle().equals(1)) {
                // 周
                createTaskByWeek(firstExecutionTime, diffDays, nursingTasks, executeFrequency, elder, v, monthEndTime, nursingIds,nursingProjectMap);
            } else {
                // 月
                createTaskByMonth(firstExecutionTime, monthEndTime, nursingTasks, executeFrequency, elder, v, nursingIds,nursingProjectMap);
            }
        });

        if (CollUtil.isEmpty(nursingTasks)) {
            return;
        }
        saveBatch(nursingTasks);
    }

    /**
     * 按月创建任务
     *
     * @param firstExecutionTime
     * @param monthEndTime
     * @param nursingTasks
     * @param executeFrequency
     * @param elder
     * @param v
     */
    private void createTaskByMonth(LocalDateTime firstExecutionTime, LocalDateTime monthEndTime, List<NursingTask> nursingTasks, Integer executeFrequency, Elder elder, NursingProjectPlanVo v, String nursingIds, Map<Long, String> nursingProjectMap) {
        LocalDateTime executionTime = firstExecutionTime;
        Integer diffDay = (monthEndTime.plusSeconds(1).getDayOfMonth() - executionTime.getDayOfMonth()) / executeFrequency;
        for (int x = 0; x < executeFrequency; x++) {
            // 根据时间差和执行顺序计算每个任务的具体时间
            LocalDateTime seconds = executionTime.plusDays(diffDay * x);
            // 初始化护理任务对象
            NursingTask nursingTask = getNursingTask(elder, v, nursingIds, seconds,nursingProjectMap);
            // 将生成的任务添加到任务列表中
            nursingTasks.add(nursingTask);
        }
    }

    /**
     * 根据周为单位创建护理任务
     *
     * 此方法旨在根据给定的开始时间、差异天数、执行频率等参数，为指定的老人生成护理任务列表
     * 它考虑了跨年情况以及每月结束时间的限制，避免生成越过月末的有效任务
     *
     * @param firstExecutionTime 首次执行时间，用于计算后续任务的时间点
     * @param diffDays 任务之间的时间差，以天为单位，此方法专注于周级别，故此值应与7的倍数有关
     * @param nursingTasks 护理任务列表，方法将新生成的任务添加到此列表中
     * @param executeFrequency 执行频率，决定每周内任务执行的次数
     * @param elder 老人信息对象，任务相关的老人信息由此对象提供
     * @param v 护理项目计划的视图对象，包含项目ID等信息
     * @param monthEndTime 每月结束时间的限制，确保任务不会跨月生成
     * @param nursingIds 护理员ID列表，以字符串形式传递，用于分配任务给护理员
     */
    private void createTaskByWeek(LocalDateTime firstExecutionTime, long diffDays, List<NursingTask> nursingTasks, Integer executeFrequency, Elder elder, NursingProjectPlanVo v, LocalDateTime monthEndTime, String nursingIds,Map<Long, String> nursingProjectMap) {
        int i;
        // 以7天为步长遍历差异天数，创建每周的任务
        for (i = 0; i < diffDays - 7; i = i + 7) {
            // 计算每周结束时间
            LocalDateTime dayEndTime = LocalDateTime.of(firstExecutionTime.plusDays(i + 7).toLocalDate(), LocalTime.of(23, 59));
            // 计算本周的执行起始时间
            LocalDateTime executionTime = firstExecutionTime.plusDays(i);
            // 根据执行频率计算时间差，用于确定本周内各任务的时间点
            Integer diffDay = (dayEndTime.plusSeconds(1).getDayOfYear() - executionTime.getDayOfYear()) / executeFrequency;
            // 根据执行频率生成本周的任务
            for (int x = 0; x < executeFrequency; x++) {
                // 根据时间差和执行顺序计算每个任务的具体时间
                LocalDateTime seconds = executionTime.plusDays(diffDay * x);
                // 初始化护理任务对象
                NursingTask nursingTask = getNursingTask(elder, v, nursingIds, seconds,nursingProjectMap);
                // 将生成的任务添加到任务列表中
                nursingTasks.add(nursingTask);
            }
        }

        // 处理边界情况，当i超过diffDays-7且小于diffDays时
        if (i > diffDays - 7 && i < diffDays) {
            // 计算到达diffDays时的结束时间
            LocalDateTime dayEndTime = LocalDateTime.of(firstExecutionTime.plusDays(i + 7).toLocalDate(), LocalTime.of(23, 59));
            // 如果结束时间与开始时间年份不同，则返回，避免跨年任务
            if (ObjectUtil.notEqual(dayEndTime.getYear(), firstExecutionTime.getYear())) {
                return;
            }
            // 计算执行时间
            LocalDateTime executionTime = firstExecutionTime.plusDays(i);
            // 计算时间差，确定任务时间点
            Integer diffDay = (dayEndTime.plusSeconds(1).getDayOfYear() - executionTime.getDayOfYear()) / executeFrequency;
            // 根据执行频率生成任务，直到月末
            for (int x = 0; x < executeFrequency; x++) {
                // 计算每个任务的时间
                LocalDateTime seconds = executionTime.plusDays(diffDay * x);
                // 如果任务时间超过月末结束时间，则停止生成
                if (seconds.isAfter(monthEndTime)) {
                    break;
                }
                // 初始化护理任务对象
                NursingTask nursingTask = getNursingTask(elder, v, nursingIds, seconds,nursingProjectMap);
                // 将生成的任务添加到任务列表中
                nursingTasks.add(nursingTask);
            }
        }

    }




    /**
     * 按日创建任务
     * @param firstExecutionTime
     * @param diffDays
     * @param nursingTasks
     * @param executeFrequency
     * @param elder
     * @param v
     */
    /**
     * 根据天数创建护理任务
     * <p>
     * 该方法根据首次执行时间、任务间隔天数、护理任务列表、执行频率、老人信息和护理项目计划数据，
     * 创建一系列的护理任务。任务的创建以天为单位，直到达到任务间隔天数为止。
     *
     * @param firstExecutionTime 首次执行时间，标志着任务创建的起始时间
     * @param diffDays           任务间隔天数，确定需要创建任务的天数范围
     * @param nursingTasks       护理任务列表，创建的任务将被添加到此列表中
     * @param executeFrequency   执行频率，决定一天内任务执行的次数
     * @param elder              老人对象，包含执行任务的老人的信息
     * @param v                  护理项目计划数据对象，包含护理项目的相关信息
     */
    private void createTaskByDay(LocalDateTime firstExecutionTime, long diffDays, List<NursingTask> nursingTasks, Integer executeFrequency, Elder elder, NursingProjectPlanVo v, String nursingIds,Map<Long, String> nursingProjectMap) {
        // 遍历每一天，从首次执行时间开始，直到达到任务间隔天数
        for (int i = 0; i < diffDays; i++) {
            // 计算每一天的任务执行起始时间
            LocalDateTime executionTime = firstExecutionTime.plusDays(i);
            // 确定当天任务执行的结束时间（当天的23:59）
            LocalDateTime dayEndTime = LocalDateTime.of(executionTime.toLocalDate(), LocalTime.of(23, 59));
            // 计算当天内每次执行任务之间的小时差，用于确定执行时间点
            Integer diffHour = (dayEndTime.plusSeconds(1).getHour() - executionTime.getHour()) / executeFrequency;
            // 根据执行频率创建任务
            for (int x = 0; x < executeFrequency; x++) {
                // 计算每个任务的具体执行时间
                LocalDateTime seconds = executionTime.plusHours(diffHour * x);
                // 创建新的护理任务对象
                NursingTask nursingTask = getNursingTask(elder, v, nursingIds, seconds,nursingProjectMap);
                // 将生成的任务添加到任务列表中
                nursingTasks.add(nursingTask);
            }
        }
    }

    /**
     * 获取护理任务对象
     * @param elder
     * @param v
     * @param nursingIds
     * @param seconds
     * @return
     */
    private NursingTask getNursingTask(Elder elder, NursingProjectPlanVo v, String nursingIds, LocalDateTime seconds,Map<Long, String> nursingProjectMap) {
        NursingTask nursingTask = new NursingTask();
        // 设置任务状态
        nursingTask.setStatus(1);
        // 设置护理员ID列表
        nursingTask.setNursingId(nursingIds);
        // 老人姓名
        nursingTask.setElderName(elder.getName());
        // 设置床位号
        nursingTask.setBedNumber(elder.getBedNumber());

        // 设置预估服务时间
        nursingTask.setEstimatedServerTime(seconds);
        // 设置项目ID
        nursingTask.setProjectId(Long.valueOf(v.getProjectId()));
        // 设置老人ID
        nursingTask.setElderId(elder.getId());
        //匹配护理项目
        nursingTask.setProjectName(nursingProjectMap.get(nursingTask.getProjectId()));


        return nursingTask;
    }
    @Override
    public NursingTaskVo getMessageById(Long id) {

        NursingTaskVo nursingTaskVo = new NursingTaskVo();
        NursingTask nursingTask = nursingTaskMapper.selectNursingTaskById(id);
        BeanUtil.copyProperties(nursingTask,nursingTaskVo);
        if (nursingTask == null) {
           throw new BaseException("护理任务不存在");

        }

       String name =  nursingTaskMapper.selectNursingLevel(nursingTask.getProjectId());

        LambdaQueryWrapper<Elder> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Elder::getId,nursingTask.getElderId());

        Elder elder = elderMapper.selectOne(queryWrapper);
        if (elder != null) {
            Integer sex = elder.getSex();

            int age = IdcardUtil.getAgeByIdCard(elder.getIdCardNo());
            nursingTaskVo.setAge(age);

            // 性别转换：0-女，1-男
            if (sex != null) {
                if (sex == 0) {
                    nursingTaskVo.setSex("女");
                } else if (sex == 1) {
                    nursingTaskVo.setSex("男");
                } else {
                    nursingTaskVo.setSex("未知"); // 处理其他可能的值
                }
            }
        }

       nursingTaskVo.setNursingLevelName(name);
       //查询护理人员名字
        String nursingId = nursingTask.getNursingId();
        String[] split = nursingId.split(",");
        String[] name2 = new String[split.length];
        for (int i = 0; i < split.length; i++) {
            String names = nursingTaskMapper.selectNursingUserName(split[i]);
            name2[i] = names;
        }
        nursingTaskVo.setNursingName(List.of(name2));
        LambdaQueryWrapper<NursingProject> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(NursingProject::getId,nursingTask.getProjectId());

        NursingProject nursingProject = nursingProjectMapper.selectOne(queryWrapper1);
        if (nursingProject!=null) {
            String name3 = nursingProject.getName();
            nursingTaskVo.setProjectName(name3);
        }
     String name4 =   nursingTaskMapper.selectExcuteName(nursingTask.getUpdateBy());
        nursingTaskVo.setUpdater(name4);
        return nursingTaskVo ;
    }

    @Override
    public void cancel(CancelDto cancelDto) {
        if (cancelDto == null || cancelDto.getTaskId() == null) {
            throw new BaseException("任务ID不能为空");

        }

        if (StringUtils.isBlank(cancelDto.getReason())) {

            throw new BaseException("取消原因不能为空");
        }
// 2. 查询护理任务是否存在
        NursingTask nursingTask = nursingTaskMapper.selectNursingTaskById(cancelDto.getTaskId());
        if (nursingTask == null) {

            throw new BaseException("护理任务不存在");
        }
        // 3. 检查任务状态（只有待执行的任务才能取消）
        if (nursingTask.getStatus() != 1) { // 1-待执行
            nursingTask.setStatus(3);

            throw new BaseException("只有待执行的任务才能取消，当前状态为：" + "已关闭");
        }
        NursingTask updateTask = new NursingTask();
        updateTask.setId(cancelDto.getTaskId());
        updateTask.setCancelReason(cancelDto.getReason());
        updateTask.setStatus(3); // 3-已取消
        //更新数据
      nursingTaskMapper.updateNursingTask(updateTask);

    }

    @Override
    public void doExecute(ExecuteTaskDto dto) {

        // 1. 参数校验：必传字段不能为空
        if (dto.getTaskId() == null) {
            throw new BaseException("任务ID不能为空，请选择具体任务");
        }
        if (dto.getEstimatedServerTime()== null) {
            throw new BaseException("执行时间不能为空，请选择执行时间");
        }

        // 2. 根据taskId查询任务是否存在
        NursingTask task = nursingTaskMapper.selectById(dto.getTaskId());
        if (task == null) {
            throw new BaseException("任务不存在或已被删除，无法执行");
        }
// 3. 检查任务状态：避免重复执行（如果状态已为“已执行”，不允许再次执行）

        if (task.getStatus() == 2) {
            throw new BaseException("该任务已执行，无需重复操作");
        }
        if (task.getStatus() == 3) {
            throw new BaseException("该任务已取消，无法执行");
        }
        // 4. 更新任务执行信息
        task.setStatus(2); // 状态改为“已执行”
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime actualTime = LocalDateTime.parse(dto.getEstimatedServerTime(), formatter);
        task.setRealServerTime(actualTime); // 实际执行时间
        task.setMark(dto.getMark()); // 执行记录（如“正确执行”）
        // 处理执行图片（如果有上传）：这里假设前端传递的是图片URL，直接保存
        if (dto.getTaskImage() != null && !dto.getTaskImage().isEmpty()) {
            task.setTaskImage(dto.getTaskImage());
        }
        // 更新时间和操作人（如果有审计字段）

        task.setUpdateBy(SecurityUtils.getUsername()); // 假设从安全上下文获取当前登录人

        // 5. 保存更新到数据库
        int rows = nursingTaskMapper.updateById(task);
        if (rows != 1) {
            throw new BaseException("任务执行记录保存失败，请重试");
        }
    }

    @Override
    public void updateTime(ExecuteTaskDto dto) {
// 1. 参数校验：必传字段不能为空
        if (dto.getTaskId() == null) {
            throw new BaseException("任务ID不能为空，请选择具体任务");
        }
        if (dto.getEstimatedServerTime() == null || dto.getEstimatedServerTime().isEmpty()) {
            throw new BaseException("执行时间不能为空，请选择执行时间");
        }

        // 2. 根据taskId查询任务是否存在
        NursingTask task = nursingTaskMapper.selectById(dto.getTaskId());
        if (task == null) {
            throw new BaseException("任务不存在或已被删除，无法改期");
        }

        // 3. 检查任务状态：只有待执行的任务才能改期
        if (task.getStatus() == 2) {
            throw new BaseException("该任务已执行，无法改期");
        }
        if (task.getStatus() == 3) {
            throw new BaseException("该任务已取消，无法改期");
        }

        // 4. 解析并设置新的执行时间（使用图片中的时间格式：yyyy-MM-dd HH:mm:ss）
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime newTime = LocalDateTime.parse(dto.getEstimatedServerTime(), formatter);

            // 检查新时间是否早于当前时间
            if (newTime.isBefore(LocalDateTime.now())) {
                throw new BaseException("改期时间不能早于当前时间");
            }

            task.setEstimatedServerTime(newTime);
        } catch (DateTimeParseException e) {
            throw new BaseException("时间格式不正确，请使用 yyyy-MM-dd HH:mm:ss 格式");
        }

        // 5. 更新操作信息
        task.setUpdateBy(SecurityUtils.getUsername());


        // 6. 保存更新到数据库
        int rows = nursingTaskMapper.updateById(task);
        if (rows != 1) {
            throw new BaseException("任务改期失败，请重试");
        }
    }
}
